package com.longau.guinea.util;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHeaders;
import org.apache.http.HttpResponse;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public final class HttpUtil {
	private final static Logger logger = LoggerFactory.getLogger(HttpUtil.class);
	private static Header[] cookies;
	private static String DEFCHARSET = "UTF-8";
	private static String cookie;

	private HttpUtil() {
	}

	public static final String httpClientPost(String url) {
		String result = "";
		HttpClient client = new HttpClient();
		GetMethod getMethod = new GetMethod(url);
		try {
			client.executeMethod(getMethod);
			result = getMethod.getResponseBodyAsString();
		} catch (Exception e) {
			logger.error(e.getMessage());
		} finally {
			getMethod.releaseConnection();
		}
		return result;
	}

	public static final String httpClientPost(String url, ArrayList<NameValuePair> list) {
		String result = "";
		HttpClient client = new HttpClient();
		PostMethod postMethod = new PostMethod(url);
		try {
			NameValuePair[] params = new NameValuePair[list.size()];
			for (int i = 0; i < list.size(); i++) {
				params[i] = list.get(i);
			}
			postMethod.addParameters(params);
			client.executeMethod(postMethod);
			result = postMethod.getResponseBodyAsString();
		} catch (Exception e) {
			logger.error(e.getMessage());
		} finally {
			postMethod.releaseConnection();
		}
		return result;
	}

	/**
	 * 发送 post请求访问本地应用并根据传递参数不同返回不同结果
	 */
	public static String post(String url, Map<String, String> params, String referer) {
		// 创建默认的httpClient实例.
		CloseableHttpClient httpclient = HttpClients.createDefault();
		// 创建httppost
		String result = "";
		HttpPost httppost = new HttpPost(url);

		setCookie(httppost);

		httppost.addHeader(HttpHeaders.REFERER, referer);
		// 创建参数队列
		List<BasicNameValuePair> formparams = new ArrayList<BasicNameValuePair>();
		if (params != null && !params.isEmpty()) {
			Set<Entry<String, String>> entrySet = params.entrySet();

			for (Entry<String, String> entry : entrySet) {
				formparams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
			}
		}
		UrlEncodedFormEntity uefEntity;
		try {
			uefEntity = new UrlEncodedFormEntity(formparams, DEFCHARSET);
			httppost.setEntity(uefEntity);

			CloseableHttpResponse response = httpclient.execute(httppost);
			try {

				getCookie(response);

				HttpEntity entity = response.getEntity();
				if (entity != null) {
					result = EntityUtils.toString(entity, DEFCHARSET);
				}
			} finally {
				response.close();
			}
		} catch (ClientProtocolException e) {
			logger.error(e.getMessage());
			;
		} catch (UnsupportedEncodingException e1) {
			e1.printStackTrace();
		} catch (IOException e) {
			logger.error(e.getMessage());
			;
		} finally {
			// 关闭连接,释放资源
			try {
				httpclient.close();
			} catch (IOException e) {
				logger.error(e.getMessage());
				;
			}
		}
		return result;
	}

	/**
	 * 发送 get请求
	 * 
	 * @return
	 */
	public static String get(String url, String referer) {
		String result = "";
		CloseableHttpClient httpclient = HttpClients.createDefault();
		try {
			// 创建httpget
			HttpGet httpget = new HttpGet(url);

			// 设置cookie
			setCookie(httpget);

			httpget.addHeader(HttpHeaders.REFERER, referer);
			httpget.addHeader(HttpHeaders.HOST, "www.k.com");

			// 执行get请求.
			CloseableHttpResponse response = httpclient.execute(httpget);
			try {
				getCookie(response);
				// 获取响应实体
				HttpEntity entity = response.getEntity();
				if (entity != null) {

					result = EntityUtils.toString(entity, DEFCHARSET);
				}
			} finally {
				response.close();
			}
		} catch (ClientProtocolException e) {
			logger.error(e.getMessage());
			;
		} catch (ParseException e) {
			logger.error(e.getMessage());
			;
		} catch (IOException e) {
			logger.error(e.getMessage());
			;
		} finally {
			// 关闭连接,释放资源
			try {
				httpclient.close();
			} catch (IOException e) {
				logger.error(e.getMessage());
				;
			}
		}
		return result;
	}

	/**
	 * 上传文件
	 * 
	 * @param url
	 *            url
	 * @param fileList
	 *            文件列表，key是参数名
	 * @param paramList
	 *            参数列表
	 */
	public static void upload(String url, Map<String, File> fileList, Map<String, String> paramList) {
		CloseableHttpClient httpclient = HttpClients.createDefault();
		try {
			HttpPost httppost = new HttpPost(url);
			setCookie(httppost);

			MultipartEntityBuilder builder = MultipartEntityBuilder.create();
			// 增加上传文件
			for (Entry<String, File> entry : fileList.entrySet()) {
				builder.addBinaryBody(entry.getKey(), entry.getValue());
			}
			// 增加参数
			for (Entry<String, String> entry : paramList.entrySet()) {
				builder.addPart(entry.getKey(), new StringBody(entry.getValue(), ContentType.TEXT_PLAIN));
			}
			HttpEntity reqEntity = builder.build();

			httppost.setEntity(reqEntity);

			System.out.println("executing request " + httppost.getRequestLine());
			CloseableHttpResponse response = httpclient.execute(httppost);
			try {
				System.out.println("----------------------------------------");
				System.out.println(response.getStatusLine());
				HttpEntity resEntity = response.getEntity();
				if (resEntity != null) {
					System.out.println("Response content length: " + resEntity.getContentLength());
				}
				EntityUtils.consume(resEntity);
			} finally {
				response.close();
			}
		} catch (ClientProtocolException e) {
			logger.error(e.getMessage());
			;
		} catch (IOException e) {
			logger.error(e.getMessage());
			;
		} finally {
			try {
				httpclient.close();
			} catch (IOException e) {
				logger.error(e.getMessage());
				;
			}
		}
	}

	public static void download(String fileUrl, File file) throws Exception {

		HttpClient client = new HttpClient();
		GetMethod get = new GetMethod(fileUrl);
		client.executeMethod(get);

		FileOutputStream output = null;
		try {
			output = new FileOutputStream(file);
			// 得到网络资源的字节数组,并写入文件
			output.write(get.getResponseBody());
		} catch (Exception e) {

			logger.error(e.getMessage());
			;
		} finally {
			output.close();
		}
	}

	private static void setCookie(HttpRequestBase http) {
		if (cookie == null || "".equals(cookie)) {
			if (cookies != null) {
				cookie = new String();
				for (Header cook : cookies) {
					// System.out.println("读cookie"+cook.getValue());
					cookie += cook.getValue() + ";";
				}
			}
		}
		System.out.println("设置cookie" + cookie);
		http.addHeader("Cookie", cookie);

	}

	private static void getCookie(HttpResponse response) {

		Header[] headers = response.getHeaders("Set-Cookie");
		if (headers != null && headers.length > 0) {
			cookies = headers;

		}
	}

	public static void main(String[] args) {
		Random random = new Random(System.currentTimeMillis());
		for(int i=0;i<10;i++) {
	System.out.println(random(random));
		}
	}
	
	
	private static Double random(Random random ) {
		int max = 20;
		int min = -4;
		int s = random.nextInt(max) % (max - min + 1) + min;
		return Double.valueOf(String.valueOf(s));
	}
}
